package com.cdp.web.controller.system.excelOperation;

import com.cdp.common.core.domain.AjaxResult;
import com.cdp.system.dto.DownloadTemplateDTO;
import com.cdp.system.dto.ExcelDTO;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Excel 操作控制器
 */
@RestController
@RequestMapping
public class ExcelController {


    @Value("${filePython.template-url}")
    private String templateUrl;

    @Value("${filePython.upload-pkl-excel}")
    private String templateUrlUploadPklExcel;


    /**
     * 删除指定行并保存 Excel
     */
//    @PostMapping("deleteExcelByAnomalyRows")
//    public AjaxResult deleteExcel(@RequestBody ExcelDTO excelDTO) {
//
//        String filePath = excelDTO.getXlsxFile();
//
//        File file = new File(filePath);
//        System.out.println("检查文件路径: " + file.getAbsolutePath());
//
//        if (!file.exists()) {
//            return new AjaxResult(507, "文件不存在: " + file.getAbsolutePath());
//        }
//
//
//        List<Integer> anomalyRows = excelDTO.getAnomalyRows();
//
//
//        if (anomalyRows == null || anomalyRows.isEmpty()) {
//            return new AjaxResult(508, "没有提供需要删除的行号");
//        }
//
//
//        anomalyRows.sort(Comparator.reverseOrder());
//
//
//        try (FileInputStream fis = new FileInputStream(file);
//             Workbook workbook = new XSSFWorkbook(fis)) {
//
//            Sheet sheet = workbook.getSheetAt(0);
//            if (sheet == null) {
//                return new AjaxResult(510, "Excel 文件为空或损坏");
//            }
//
//
//            for (int rowIndex : anomalyRows) {
//                if (rowIndex >= 0 && rowIndex <= sheet.getLastRowNum()) {
//                    removeRow(sheet, rowIndex);
//                }
//            }
//
//
//            try (FileOutputStream fos = new FileOutputStream(filePath)) {
//                workbook.write(fos);
//            }
//
//            return new AjaxResult(200, "Excel 处理完成", filePath);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return new AjaxResult(500, "处理 Excel 发生错误: " + e.getMessage());
//        }
//    }
//


    /**
     * 删除指定行并保存 Excel 为新文件
     */
    @PostMapping("deleteExcelByAnomalyRows")
    public AjaxResult deleteExcel(@RequestBody ExcelDTO excelDTO) {

        String filePath = excelDTO.getXlsxFile();

        File file = new File(filePath);
        System.out.println("检查文件路径: " + file.getAbsolutePath());

        if (!file.exists()) {
            return new AjaxResult(507, "文件不存在: " + file.getAbsolutePath());
        }

        List<Integer> anomalyRows = excelDTO.getAnomalyRows();

        if (anomalyRows == null || anomalyRows.isEmpty()) {
            return new AjaxResult(508, "没有提供需要删除的行号");
        }

        anomalyRows.sort(Comparator.reverseOrder());  // 逆序删除行，防止索引错乱

        // 生成新文件名：使用当前毫秒时间戳和随机数
        String timestamp = String.valueOf(System.currentTimeMillis());  // 当前毫秒时间戳
        String random = String.valueOf((int) (Math.random() * 1000));  // 生成一个随机数
        String newFileName = timestamp + "_" + random + ".xlsx";  // 结合时间戳和随机数
        String newFilePath = filePath.substring(0, filePath.lastIndexOf(File.separator)) + File.separator + newFileName;

        File newFile = new File(newFilePath);

        try (FileInputStream fis = new FileInputStream(file);
             Workbook workbook = new XSSFWorkbook(fis)) {

            Sheet sheet = workbook.getSheetAt(0);
            if (sheet == null) {
                return new AjaxResult(510, "Excel 文件为空或损坏");
            }

            // 删除指定的行
            for (int rowIndex : anomalyRows) {
                if (rowIndex >= 0 && rowIndex <= sheet.getLastRowNum()) {
                    removeRow(sheet, rowIndex);
                }
            }

            // 保存到新的文件路径
            try (FileOutputStream fos = new FileOutputStream(newFile)) {
                workbook.write(fos);
            }

            return new AjaxResult(200, "Excel 处理完成", newFilePath);
        } catch (Exception e) {
            e.printStackTrace();
            return new AjaxResult(500, "处理 Excel 发生错误: " + e.getMessage());
        }
    }


    /**
     * **删除 Excel 中的行**
     */
    private void removeRow(Sheet sheet, int rowIndex) {
        int lastRowNum = sheet.getLastRowNum();
        Row row = sheet.getRow(rowIndex);
        if (row != null) {
            sheet.removeRow(row);
            if (rowIndex < lastRowNum) {
                sheet.shiftRows(rowIndex + 1, lastRowNum, -1);
            }
        }
    }



/*

    @PostMapping("/readExcel")
    public AjaxResult readExcel(@RequestBody ExcelDTO excelDTO) {
        String xlsxFile = excelDTO.getXlsxFile();
        List<Map<String, Object>> data = new ArrayList<>();
        try {
            // 创建输入流读取 Excel 文件
            FileInputStream fis = new FileInputStream(new File(xlsxFile));
            Workbook workbook = WorkbookFactory.create(fis);

            // 获取第一个 sheet
            Sheet sheet = workbook.getSheetAt(0);

            // 获取第一行的列头
            Row headerRow = sheet.getRow(0);
            List<String> headers = new ArrayList<>();
            for (int i = 0; i < headerRow.getPhysicalNumberOfCells(); i++) {
                headers.add(headerRow.getCell(i).getStringCellValue());
            }

            // 遍历 sheet 中的每一行（从第二行开始，因为第一行是标题行）
            Iterator<Row> rowIterator = sheet.iterator();
            rowIterator.next();  // 跳过标题行
            while (rowIterator.hasNext()) {
                Row row = rowIterator.next();
                Map<String, Object> rowData = new HashMap<>();
                // 遍历该行中的每一列
                for (int i = 0; i < row.getPhysicalNumberOfCells(); i++) {
                    Cell cell = row.getCell(i);
                    rowData.put(headers.get(i), cellToString(cell));  // 用标题行的列名作为键
                }
                data.add(rowData);
            }

            workbook.close();
            fis.close();


            HashMap<Object, Object> map = new HashMap<>();
            map.put("head",)
            map.put("data",data);

            // 返回读取到的数据
            return AjaxResult.success(map);

        } catch (IOException e) {
            e.printStackTrace();
            return AjaxResult.error("读取 Excel 文件失败");
        }
    }


    // 根据不同的单元格类型转换为字符串
    private String cellToString(Cell cell) {
        if (cell == null) {
            return "";
        }
        switch (cell.getCellType()) {
            case STRING:
                return cell.getStringCellValue();
            case NUMERIC:
                if (DateUtil.isCellDateFormatted(cell)) {
                    // 处理日期格式
                    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
                    return dateFormat.format(cell.getDateCellValue());
                } else {
                    return String.valueOf(cell.getNumericCellValue());
                }
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            case FORMULA:
                return cell.getCellFormula();
            default:
                return "";
        }
    }

*/


    @PostMapping("/readExcel")
    public AjaxResult readExcel(@RequestBody ExcelDTO excelDTO) {
        String xlsxFile = excelDTO.getXlsxFile();
        List<Map<String, Object>> data = new ArrayList<>();
        List<String> head = new ArrayList<>();

        try {
            // 创建输入流读取 Excel 文件
            FileInputStream fis = new FileInputStream(new File(xlsxFile));
            Workbook workbook = WorkbookFactory.create(fis);

            // 获取第一个 sheet
            Sheet sheet = workbook.getSheetAt(0);

            // 获取第一行的列头
            Row headerRow = sheet.getRow(0);
            for (int i = 0; i < headerRow.getPhysicalNumberOfCells(); i++) {
                head.add(cellToString(headerRow.getCell(i))); // 直接转换单元格内容
            }

            // 遍历 sheet 中的每一行（从第二行开始，因为第一行是标题行）
            Iterator<Row> rowIterator = sheet.iterator();
            rowIterator.next();  // 跳过标题行
            while (rowIterator.hasNext()) {
                Row row = rowIterator.next();
                Map<String, Object> rowData = new HashMap<>();
                // 遍历该行中的每一列
                for (int i = 0; i < row.getPhysicalNumberOfCells(); i++) {
                    Cell cell = row.getCell(i);
                    rowData.put(head.get(i), cellToString(cell));  // 用标题行的列名作为键
                }
                data.add(rowData);
            }

            workbook.close();
            fis.close();

            // 组织返回的数据
            Map<String, Object> resultMap = new HashMap<>();
            resultMap.put("head", head);  // 表头
            resultMap.put("data", data);  // 数据

            return AjaxResult.success(resultMap);

        } catch (IOException e) {
            e.printStackTrace();
            return AjaxResult.error("读取 Excel 文件失败");
        }
    }

    // 根据不同的单元格类型转换为字符串
    private String cellToString(Cell cell) {
        if (cell == null) {
            return "";
        }
        switch (cell.getCellType()) {
            case STRING:
                return cell.getStringCellValue();
            case NUMERIC:
                if (DateUtil.isCellDateFormatted(cell)) {
                    // 处理日期格式
                    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
                    return dateFormat.format(cell.getDateCellValue());
                } else {
                    return String.valueOf(cell.getNumericCellValue());
                }
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            case FORMULA:
                return cell.getCellFormula();
            default:
                return "";
        }
    }


    /**
     * 根据文件地址和表头查询数据
     *
     * @param excelDTO
     * @return
     */
//    @PostMapping("/readUnusualExcel")
//    public AjaxResult readUnusualExcel(@RequestBody ExcelDTO excelDTO) {
//
//        List<Integer> anomalyRows = excelDTO.getAnomalyRows();
//
//        String xlsxFile = excelDTO.getXlsxFile();
//        List<String> anomalyColumns = excelDTO.getData(); // 这里是表头名称
//
//        if (xlsxFile == null || xlsxFile.isEmpty()) {
//            return AjaxResult.error("Excel 文件路径不能为空");
//        }
//
//        File file = new File(xlsxFile);
//        if (!file.exists()) {
//            return AjaxResult.error("Excel 文件不存在");
//        }
//
//        List<Map<String, String>> resultData = new ArrayList<>();
//
//        try (FileInputStream fis = new FileInputStream(file);
//             Workbook workbook = new XSSFWorkbook(fis)) {
//
//            Sheet sheet = workbook.getSheetAt(0); // 读取第一个工作表
//            Row headerRow = sheet.getRow(0); // 读取表头
//            if (headerRow == null) {
//                return AjaxResult.error("Excel 文件无表头数据");
//            }
//
//            // 1️⃣ 获取表头信息，并找到目标列索引
//            Map<String, Integer> headerIndexMap = new HashMap<>();
//            for (int i = 0; i < headerRow.getLastCellNum(); i++) {
//                Cell cell = headerRow.getCell(i);
//                if (cell != null) {
//                    headerIndexMap.put(cell.getStringCellValue(), i);
//                }
//            }
//
//            // 2️⃣ 找到 `anomalyRows` 对应的列索引
//            List<Integer> targetColumns = new ArrayList<>();
//            for (String columnName : anomalyColumns) {
//                Integer colIndex = headerIndexMap.get(columnName);
//                if (colIndex != null) {
//                    targetColumns.add(colIndex);
//                }
//            }
//
//            if (targetColumns.isEmpty()) {
//                return AjaxResult.error("指定的表头字段未找到：" + anomalyColumns);
//            }
//
//            // 3️⃣ 遍历 Excel 读取指定列的数据
//            for (int rowIndex = 1; rowIndex <= sheet.getLastRowNum(); rowIndex++) {
//                Row row = sheet.getRow(rowIndex);
//                if (row != null) {
//                    Map<String, String> rowData = new HashMap<>();
//                    for (Integer colIndex : targetColumns) {
//                        Cell cell = row.getCell(colIndex);
//                        String headerName = headerRow.getCell(colIndex).getStringCellValue();
//                        rowData.put(headerName, getCellValue(cell));
//                    }
//                    resultData.add(rowData);
//                }
//            }
//
//        } catch (IOException e) {
//            return AjaxResult.error("读取 Excel 失败: " + e.getMessage());
//        }
//
//
//        Map<String, Object> resultMap = new HashMap<>();
//        resultMap.put("head", anomalyColumns);  // 表头
//        resultMap.put("data", resultData);  // 数据
//
//
//
//        return AjaxResult.success(resultMap);
//    }
//
//    /**
//     * 获取单元格数据
//     */
//    private String getCellValue(Cell cell) {
//        if (cell == null) {
//            return "";
//        }
//
//        switch (cell.getCellType()) {
//            case STRING:
//                return cell.getStringCellValue();
//            case NUMERIC:
//                if (DateUtil.isCellDateFormatted(cell)) {
//                    // JDK 8 兼容的日期格式化
//                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//                    return sdf.format(cell.getDateCellValue());
//                }
//                return String.valueOf(cell.getNumericCellValue());
//            case BOOLEAN:
//                return String.valueOf(cell.getBooleanCellValue());
//            case FORMULA:
//                return cell.getCellFormula();
//            default:
//                return "";
//        }
//
//
//    }
//


//    @PostMapping("/readUnusualExcel")
//    public AjaxResult readUnusualExcel(@RequestBody ExcelDTO excelDTO) {
//
//        List<Integer> anomalyRows = excelDTO.getAnomalyRows();  // 获取异常行号
//        String xlsxFile = excelDTO.getXlsxFile();
//        List<String> anomalyColumns = excelDTO.getData(); // 获取表头字段
//
//        if (xlsxFile == null || xlsxFile.isEmpty()) {
//            return AjaxResult.error("Excel 文件路径不能为空");
//        }
//
//        File file = new File(xlsxFile);
//        if (!file.exists()) {
//            return AjaxResult.error("Excel 文件不存在");
//        }
//
//        List<Map<String, String>> resultData = new ArrayList<>();
//
//        try (FileInputStream fis = new FileInputStream(file);
//             Workbook workbook = new XSSFWorkbook(fis)) {
//
//            Sheet sheet = workbook.getSheetAt(0); // 读取第一个工作表
//            Row headerRow = sheet.getRow(0); // 读取表头
//            if (headerRow == null) {
//                return AjaxResult.error("Excel 文件无表头数据");
//            }
//
//            // 1️⃣ 获取表头信息，并找到目标列索引
//            Map<String, Integer> headerIndexMap = new HashMap<>();
//            for (int i = 0; i < headerRow.getLastCellNum(); i++) {
//                Cell cell = headerRow.getCell(i);
//                if (cell != null) {
//                    headerIndexMap.put(cell.getStringCellValue(), i);
//                }
//            }
//
//            // 2️⃣ 找到 `anomalyColumns` 对应的列索引
//            List<Integer> targetColumns = new ArrayList<>();
//            for (String columnName : anomalyColumns) {
//                Integer colIndex = headerIndexMap.get(columnName);
//                if (colIndex != null) {
//                    targetColumns.add(colIndex);
//                }
//            }
//
//            if (targetColumns.isEmpty()) {
//                return AjaxResult.error("指定的表头字段未找到：" + anomalyColumns);
//            }
//
//            // 3️⃣ 遍历 Excel 读取指定行数据，只处理 anomalyRows 中的行
//            for (int rowIndex = 1; rowIndex <= sheet.getLastRowNum(); rowIndex++) {
//                if (anomalyRows.contains(rowIndex)) {  // 只读取 anomalyRows 中的行
//                    Row row = sheet.getRow(rowIndex);
//                    if (row != null) {
//                        Map<String, String> rowData = new HashMap<>();
//                        for (Integer colIndex : targetColumns) {
//                            Cell cell = row.getCell(colIndex);
//                            String headerName = headerRow.getCell(colIndex).getStringCellValue();
//                            rowData.put(headerName, getCellValue(cell));
//                        }
//                        resultData.add(rowData);
//                    }
//                }
//            }
//
//        } catch (IOException e) {
//            return AjaxResult.error("读取 Excel 失败: " + e.getMessage());
//        }
//
//        Map<String, Object> resultMap = new HashMap<>();
//        resultMap.put("head", anomalyColumns);  // 表头
//        resultMap.put("data", resultData);  // 数据
//
//        return AjaxResult.success(resultMap);
//    }
    @PostMapping("/readUnusualExcel")
    public AjaxResult readUnusualExcel(@RequestBody ExcelDTO excelDTO) {
        List<Integer> anomalyRows = excelDTO.getAnomalyRows();  // 获取异常行号
        String xlsxFile = excelDTO.getXlsxFile();
        List<String> anomalyColumns = excelDTO.getData(); // 获取表头字段

        // 校验 Excel 文件路径是否为空或文件不存在
        if (xlsxFile == null || xlsxFile.trim().isEmpty()) {
            return AjaxResult.error("Excel 文件路径不能为空");
        }

        File file = new File(xlsxFile);
        if (!file.exists()) {
            return AjaxResult.error("Excel 文件不存在");
        }

        // 替换 "石掺量" 为多个新字段
        if (anomalyColumns.contains("石掺量")) {
            anomalyColumns.remove("石掺量");
            anomalyColumns.addAll(Arrays.asList(
                    "石5-10mm掺量",
                    "石5-25mm掺量",
                    "石20-40mm掺量",
                    "石10-20mm掺量",
                    "石10-30mm掺量",
                    "石0-10mm掺量",
                    "石20-31.5mm掺量"
            ));
        }

        // 替换 "石堆积密度" 为多个新字段
        if (anomalyColumns.contains("石堆积密度")) {
            anomalyColumns.remove("石堆积密度");
            anomalyColumns.addAll(Arrays.asList(
                    "石5-10mm堆积密度(kg/m³)",
                    "石5-25mm堆积密度(kg/m³)",
                    "石20-40mm堆积密度(kg/m³)",
                    "石10-20mm堆积密度(kg/m³)",
                    "石10-30mm堆积密度(kg/m³)",
                    "石0-10mm堆积密度(kg/m³)",
                    "石20-31.5mm堆积密度(kg/m³)"
            ));
        }

        // 替换 "石紧密密度" 为多个新字段
        if (anomalyColumns.contains("石紧密密度")) {
            anomalyColumns.remove("石紧密密度");
            anomalyColumns.addAll(Arrays.asList(
                    "石5-10mm紧密密度(kg/m³)",
                    "石5-25mm紧密密度(kg/m³)",
                    "石20-40mm紧密密度(kg/m³)",
                    "石10-20mm紧密密度(kg/m³)",
                    "石10-30mm紧密密度(kg/m³)",
                    "石0-10mm紧密密度(kg/m³)",
                    "石20-31.5mm紧密密度(kg/m³)"
            ));
        }

        // 替换 "石表观密度" 为多个新字段
        if (anomalyColumns.contains("石表观密度")) {
            anomalyColumns.remove("石表观密度");
            anomalyColumns.addAll(Arrays.asList(
                    "石5-10mm表观密度(kg/m³)",
                    "石5-25mm表观密度(kg/m³)",
                    "石20-40mm表观密度(kg/m³)",
                    "石10-20mm表观密度(kg/m³)",
                    "石10-30mm表观密度(kg/m³)",
                    "石0-10mm表观密度(kg/m³)",
                    "石20-31.5mm表观密度(kg/m³)"
            ));
        }

        // 替换 "砂掺量" 为多个新字段
        if (anomalyColumns.contains("砂掺量")) {
            anomalyColumns.remove("砂掺量");
            anomalyColumns.addAll(Arrays.asList(
                    "河砂粗3.1-3.7mm掺量",
                    "河砂中2.3-3.0mm掺量",
                    "河砂细1.6-2.2mm掺量",
                    "机制砂中2.3-3.0mm掺量",
                    "机制砂粗3.1-3.7mm掺量",
                    "机制砂细1.6-2.2mm掺量",
                    "机制砂0-4.75mm掺量",
                    "机制砂0-9mm掺量"
            ));
        }

        // 替换 "砂细度" 为多个新字段
        if (anomalyColumns.contains("砂细度")) {
            anomalyColumns.remove("砂细度");
            anomalyColumns.addAll(Arrays.asList(
                    "河砂粗3.1-3.7mm细度",
                    "河砂中2.3-3.0mm细度",
                    "河砂细1.6-2.2mm细度",
                    "机制砂中2.3-3.0mm细度",
                    "机制砂粗3.1-3.7mm细度",
                    "机制砂细1.6-2.2mm细度",
                    "机制砂0-4.75mm细度",
                    "机制砂0-9mm细度"
            ));
        }

        // 替换 "砂堆积密度" 为多个新字段
        if (anomalyColumns.contains("砂堆积密度")) {
            anomalyColumns.remove("砂堆积密度");
            anomalyColumns.addAll(Arrays.asList(
                    "河砂粗3.1-3.7mm堆积密度(kg/m³)",
                    "河砂中2.3-3.0mm堆积密度(kg/m³)",
                    "河砂细1.6-2.2mm堆积密度(kg/m³)",
                    "机制砂中2.3-3.0mm堆积密度(kg/m³)",
                    "机制砂粗3.1-3.7mm堆积密度(kg/m³)",
                    "机制砂细1.6-2.2mm堆积密度(kg/m³)",
                    "机制砂0-4.75mm堆积密度(kg/m³)",
                    "机制砂0-9mm堆积密度(kg/m³)"
            ));
        }

        // 替换 "砂紧密密度" 为多个新字段
        if (anomalyColumns.contains("砂紧密密度")) {
            anomalyColumns.remove("砂紧密密度");
            anomalyColumns.addAll(Arrays.asList(
                    "河砂粗3.1-3.7mm紧密密度(kg/m³)",
                    "河砂中2.3-3.0mm紧密密度(kg/m³)",
                    "河砂细1.6-2.2mm紧密密度(kg/m³)",
                    "机制砂中2.3-3.0mm紧密密度(kg/m³)",
                    "机制砂粗3.1-3.7mm紧密密度(kg/m³)",
                    "机制砂细1.6-2.2mm紧密密度(kg/m³)",
                    "机制砂0-4.75mm紧密密度(kg/m³)",
                    "机制砂0-9mm紧密密度(kg/m³)"
            ));
        }

        // 替换 "砂表观密度" 为多个新字段
        if (anomalyColumns.contains("砂表观密度")) {
            anomalyColumns.remove("砂表观密度");
            anomalyColumns.addAll(Arrays.asList(
                    "河砂粗3.1-3.7mm表观密度(kg/m³)",
                    "河砂中2.3-3.0mm表观密度(kg/m³)",
                    "河砂细1.6-2.2mm表观密度(kg/m³)",
                    "机制砂中2.3-3.0mm表观密度(kg/m³)",
                    "机制砂粗3.1-3.7mm表观密度(kg/m³)",
                    "机制砂细1.6-2.2mm表观密度(kg/m³)",
                    "机制砂0-4.75mm表观密度(kg/m³)",
                    "机制砂0-9mm表观密度(kg/m³)"
            ));
        }

        List<Map<String, String>> resultData = new ArrayList<>();

        try (FileInputStream fis = new FileInputStream(file);
             Workbook workbook = new XSSFWorkbook(fis)) {

            Sheet sheet = workbook.getSheetAt(0); // 读取第一个工作表
            Row headerRow = sheet.getRow(0); // 读取表头
            if (headerRow == null) {
                return AjaxResult.error("Excel 文件无表头数据");
            }

            // 1获取表头信息，并找到目标列索引
            Map<String, Integer> headerIndexMap = new HashMap<>();
            for (int i = 0; i < headerRow.getPhysicalNumberOfCells(); i++) { // 避免空白列问题
                Cell cell = headerRow.getCell(i);
                if (cell != null) {
                    headerIndexMap.put(cell.getStringCellValue().trim(), i);
                }
            }

            // 2 找到 `anomalyColumns` 对应的列索引
            List<Integer> targetColumns = new ArrayList<>();
            for (String columnName : anomalyColumns) {
                Integer colIndex = headerIndexMap.get(columnName);
                if (colIndex != null) {
                    targetColumns.add(colIndex);
                }
            }

            if (targetColumns.isEmpty()) {
                return AjaxResult.error("指定的表头字段未找到：" + anomalyColumns);
            }

            // 3️ 遍历 Excel 读取指定行数据，只处理 anomalyRows 中的行
            for (int rowIndex : anomalyRows) {
                if (rowIndex > sheet.getLastRowNum()) { // 防止索引越界
                    continue;
                }
                Row row = sheet.getRow(rowIndex);
                if (row != null) {
                    Map<String, String> rowData = new HashMap<>();
                    for (Integer colIndex : targetColumns) {
                        Cell cell = row.getCell(colIndex);
                        String headerName = headerRow.getCell(colIndex) != null ?
                                headerRow.getCell(colIndex).getStringCellValue() : "未知列";
                        rowData.put(headerName, getCellValue(cell));
                    }
                    resultData.add(rowData);
                }
            }

        } catch (IOException e) {
            return AjaxResult.error("读取 Excel 失败: " + e.getMessage());
        }

        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("head", anomalyColumns);  // 表头
        resultMap.put("data", resultData);  // 数据

        return AjaxResult.success(resultMap);
    }


//    @PostMapping("/readUnusualExcel")
//    public AjaxResult readUnusualExcel(@RequestBody ExcelDTO excelDTO) {
//        List<Integer> anomalyRows = excelDTO.getAnomalyRows();  // 获取异常行号
//        String xlsxFile = excelDTO.getXlsxFile();
//        List<String> anomalyColumns = excelDTO.getData(); // 获取表头字段
//
//        if (xlsxFile == null || xlsxFile.trim().isEmpty()) {
//            return AjaxResult.error("Excel 文件路径不能为空");
//        }
//
//        File file = new File(xlsxFile);
//        if (!file.exists()) {
//            return AjaxResult.error("Excel 文件不存在");
//        }
//
//        // 替换 "石掺量" 为多个新字段
//        if (anomalyColumns.contains("石掺量")) {
//            anomalyColumns.remove("石掺量");
//            anomalyColumns.addAll(Arrays.asList(
//                    "石5-10mm掺量",
//                    "石5-25mm掺量",
//                    "石20-40mm掺量",
//                    "石10-20mm掺量",
//                    "石10-30mm掺量",
//                    "石0-10mm掺量",
//                    "石20-31.5mm掺量"
//            ));
//        }
//
//
//
//
//
//
//
//
//
//
//        List<Map<String, String>> resultData = new ArrayList<>();
//
//        try (FileInputStream fis = new FileInputStream(file);
//             Workbook workbook = new XSSFWorkbook(fis)) {
//
//            Sheet sheet = workbook.getSheetAt(0); // 读取第一个工作表
//            Row headerRow = sheet.getRow(0); // 读取表头
//            if (headerRow == null) {
//                return AjaxResult.error("Excel 文件无表头数据");
//            }
//
//            // 1️⃣ 获取表头信息，并找到目标列索引
//            Map<String, Integer> headerIndexMap = new HashMap<>();
//            for (int i = 0; i < headerRow.getPhysicalNumberOfCells(); i++) { // 避免空白列问题
//                Cell cell = headerRow.getCell(i);
//                if (cell != null) {
//                    headerIndexMap.put(cell.getStringCellValue().trim(), i);
//                }
//            }
//
//            // 2️⃣ 找到 `anomalyColumns` 对应的列索引
//            List<Integer> targetColumns = new ArrayList<>();
//            for (String columnName : anomalyColumns) {
//                Integer colIndex = headerIndexMap.get(columnName);
//                if (colIndex != null) {
//                    targetColumns.add(colIndex);
//                }
//            }
//
//            if (targetColumns.isEmpty()) {
//                return AjaxResult.error("指定的表头字段未找到：" + anomalyColumns);
//            }
//
//            // 3️⃣ 遍历 Excel 读取指定行数据，只处理 anomalyRows 中的行
//            for (int rowIndex : anomalyRows) {
//                if (rowIndex > sheet.getLastRowNum()) { // 防止索引越界
//                    continue;
//                }
//                Row row = sheet.getRow(rowIndex);
//                if (row != null) {
//                    Map<String, String> rowData = new HashMap<>();
//                    for (Integer colIndex : targetColumns) {
//                        Cell cell = row.getCell(colIndex);
//                        String headerName = headerRow.getCell(colIndex) != null ?
//                                headerRow.getCell(colIndex).getStringCellValue() : "未知列";
//                        rowData.put(headerName, getCellValue(cell));
//                    }
//                    resultData.add(rowData);
//                }
//            }
//
//        } catch (IOException e) {
//            return AjaxResult.error("读取 Excel 失败: " + e.getMessage());
//        }
//
//        Map<String, Object> resultMap = new HashMap<>();
//        resultMap.put("head", anomalyColumns);  // 表头
//        resultMap.put("data", resultData);  // 数据
//
//        return AjaxResult.success(resultMap);
//    }
//


    /**
     * 获取单元格数据
     */
    private String getCellValue(Cell cell) {
        if (cell == null) {
            return "";
        }

        switch (cell.getCellType()) {
            case STRING:
                return cell.getStringCellValue();
            case NUMERIC:
                if (DateUtil.isCellDateFormatted(cell)) {
                    // JDK 8 兼容的日期格式化
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                    return sdf.format(cell.getDateCellValue());
                }
                return String.valueOf(cell.getNumericCellValue());
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            case FORMULA:
                return cell.getCellFormula();
            default:
                return "";
        }
    }


    /**
     * 根据文件地址下载文件
     */
    @GetMapping("/downloadTemplate")
    public void downloadTemplate(HttpServletResponse response) {
        String filePath = templateUrlUploadPklExcel + "mechanicalPerformance.xlsx";
        // String filePath = "C:\\Users\\Administrator\\Desktop\\2\\2\\模版.xlsx";
        File file = new File(filePath);

        if (!file.exists()) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setHeader("Content-Disposition", "attachment; filename=" + file.getName());
        response.setContentLength((int) file.length());

        try (FileInputStream fis = new FileInputStream(file);
             OutputStream os = response.getOutputStream()) {

            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            os.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 下载总模版
     *
     * @param response
     */


    @PostMapping("/downloadTemplateTotal")
    public void downloadTemplateTotal(HttpServletResponse response, @RequestBody DownloadTemplateDTO dto) {
        Integer type = dto.getType();
        String filePath;
//type  0:力学性能 1:坍落度 2:Erp力学性能 3:Eerp坍落度 4 :水泥  5:石头 6: 砂  7:粉煤灰 8:矿粉 9:石粉 10:减水剂 11:增效剂 12:膨胀剂
        if (type == 0) {
            filePath = templateUrlUploadPklExcel + "mechanicalPerformance.xlsx";
        } else if (type == 1) {
            filePath = templateUrlUploadPklExcel + "slump.xlsx";
        } else if (type == 2) {
            filePath = templateUrlUploadPklExcel + "ErpmechanicalPerformance.xlsx";
        } else if (type == 3) {
            filePath = templateUrlUploadPklExcel + "ErpSlump.xlsx";
        } else if (type == 4) {
            filePath = templateUrlUploadPklExcel + "Cement.xlsx";
        } else if (type == 5) {
            filePath = templateUrlUploadPklExcel + "Stone.xlsx";
        } else if (type == 6) {
            filePath = templateUrlUploadPklExcel + "Sand.xlsx";
        } else if (type == 7) {
            filePath = templateUrlUploadPklExcel + "Flash.xlsx";

        } else if (type == 8) {
            filePath = templateUrlUploadPklExcel + "mineralPowder.xlsx";

        } else if (type == 9) {
            filePath = templateUrlUploadPklExcel + "otherAdmixtures.xlsx";

        } else if (type == 10) {
            filePath = templateUrlUploadPklExcel + "waterReducer.xlsx";

        } else if (type == 11) {
            filePath = templateUrlUploadPklExcel + "efficiencyAgent.xlsx";

        } else if (type == 12) {
            filePath = templateUrlUploadPklExcel + "swellingagent.xlsx";
        } else {
            response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
            return;
        }

        File file = new File(filePath);

        if (!file.exists()) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setHeader("Content-Disposition", "attachment; filename=" + file.getName());
        response.setContentLengthLong(file.length());

        try (FileInputStream fis = new FileInputStream(file);
             OutputStream os = response.getOutputStream()) {

            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            os.flush();
        } catch (IOException e) {
            e.printStackTrace();
            response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }
    }


    /**
     * 根据文件地址下载文件
     */
    @GetMapping("/downloadExcelByUrl")
    public void downloadExcelByUrl(@RequestParam("url") String url, HttpServletResponse response) {
        String filePath = url;
        // String filePath = "C:\\Users\\Administrator\\Desktop\\2\\2\\模版.xlsx";
        File file = new File(filePath);

        if (!file.exists()) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setHeader("Content-Disposition", "attachment; filename=" + file.getName());
        response.setContentLength((int) file.length());

        try (FileInputStream fis = new FileInputStream(file);
             OutputStream os = response.getOutputStream()) {

            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            os.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}
